{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# भाग 8 - योजनाओं का परिचय\n",
    "\n",
    "\n",
    "### प्रसंग\n",
    "\n",
    "हम यहां एक ऐसी वस्तु का परिचय देते हैं जो औद्योगिक फेडरेटेड लर्निंग: द प्लान (plan) के पैमाने पर महत्वपूर्ण है। यह नाटकीय रूप से बैंडविड्थ उपयोग को कम करता है, अतुल्यकालिक योजनाओं की अनुमति देता है और दूरस्थ उपकरणों को अधिक स्वायत्तता देता है। योजना की मूल अवधारणा को पेपर [Towards Federated Learning at Scale: System Design](https://arxiv.org/pdf/1902.01046.pdf) में पाया जा सकता है, लेकिन इसे PySyft लाइब्रेरी में हमारी आवश्यकताओं के अनुकूल बनाया गया है।\n",
    "\n",
    "एक प्लान का उद्देश्य एक कार्य की तरह, torch संचालन के अनुक्रम को संग्रहीत करना है, लेकिन यह संचालन के इस अनुक्रम को दूरस्थ श्रमिकों को भेजने और इसके लिए एक संदर्भ रखने की अनुमति देता है। इस तरह, गणित के $n$ संचालन के इस क्रम को दूरस्थ रूप से गणना करने के लिए पॉइंटर्स के माध्यम से संदर्भित कुछ दूरस्थ इनपुट पर, गणितडी $n$ संदेश भेजने के बजाय अब आपको प्लान और बिंदुओं के संदर्भ के साथ एक संदेश भेजने की आवश्यकता है। आप अपने फ़ंक्शन के साथ टेंसर्स भी प्रदान कर सकते हैं (जिसे हम विस्तारित कार्यशीलता के लिए _state tensors_ कहते हैं)। प्लान को या तो एक फ़ंक्शन की तरह देखा जा सकता है जिसे आप भेज सकते हैं, या एक वर्ग की तरह जिसे दूरस्थ रूप से भी भेजा और निष्पादित किया जा सकता है। इसलिए, उच्च स्तर के उपयोगकर्ताओं के लिए, योजना की धारणा गायब हो जाती है और इसे एक जादुई विशेषता द्वारा प्रतिस्थापित किया जाता है जो दूरस्थ श्रमिकों को मनमाने ढंग से कार्यों को भेजने की अनुमति देता है जिसमें अनुक्रमिक torch कार्य शामिल हैं।\n",
    "\n",
    "ध्यान देने वाली एक बात यह है कि जिन कार्यों को आप प्लान में बदल सकते हैं उनका वर्ग वर्तमान में विशेष रूप से हुक torch के अनुक्रमों तक सीमित है। यह विशेष रूप से तार्किक संरचनाओं में शामिल है जैसे `if`, `for` और `while` कथन, भले ही हम जल्द ही काम करने के लिए काम कर रहे हों। _पूरी तरह से सटीक होने के लिए, आप इनका उपयोग कर सकते हैं लेकिन आपके द्वारा लिए जाने वाले तार्किक पथ (उदाहरण के लिए पहले `if` को गलत और 5 छोरों को `for` में) अपने प्लान  के पहले गणना में सभी के लिए रखा गया एक होगा अगले संगणना, जिसे हम अधिकांश मामलों में बचना चाहते हैं।_\n",
    "\n",
    "लेखक:\n",
    "- Théo Ryffel - Twitter [@theoryffel](https://twitter.com/theoryffel) - Github: [@LaRiffle](https://github.com/LaRiffle)\n",
    "- Bobby Wagner - Twitter [@bobbyawagner](https://twitter.com/bobbyawagner) - GitHub: [@robert-wagner](https://github.com/robert-wagner)\n",
    "- Marianne Monteiro - Twitter [@hereismari](https://twitter.com/hereismari) - GitHub: [@mari-linhares](https://github.com/mari-linhares)\n",
    "\n",
    "nbTranslate का उपयोग करके अनुवादित\n",
    "\n",
    "संपादक:\n",
    "- Urvashi Raheja - Github: [@raheja](https://github.com/raheja)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### आयात और मॉडल विनिर्देशों\n",
    "\n",
    "पहले आधिकारिक आयात करते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "और PySyft के लिए विशिष्ट, एक महत्वपूर्ण नोट के साथ: **स्थानीय कार्यकर्ता को ग्राहक नहीं होना चाहिए।** <*> गैर ग्राहक श्रमिक वस्तुओं को स्टोर कर सकते हैं और हमें प्लान चलाने के लिए इस क्षमता की आवश्यकता है। <*>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import syft as sy  # import the Pysyft library\n",
    "hook = sy.TorchHook(torch)  # hook PyTorch ie add extra functionalities \n",
    "\n",
    "# IMPORTANT: Local worker should not be a client worker\n",
    "hook.local_worker.is_client_worker = False\n",
    "\n",
    "\n",
    "server = hook.local_worker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "हम संदर्भ लेख में प्रदान की गई धारणाओं के अनुरूप होने के लिए, दूरस्थ श्रमिकों या _devices_, को परिभाषित करते हैं।\n",
    "हम उन्हें कुछ डेटा प्रदान करते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x11 = torch.tensor([-1, 2.]).tag('input_data')\n",
    "x12 = torch.tensor([1, -2.]).tag('input_data2')\n",
    "x21 = torch.tensor([-1, 2.]).tag('input_data')\n",
    "x22 = torch.tensor([1, -2.]).tag('input_data2')\n",
    "\n",
    "device_1 = sy.VirtualWorker(hook, id=\"device_1\", data=(x11, x12)) \n",
    "device_2 = sy.VirtualWorker(hook, id=\"device_2\", data=(x21, x22))\n",
    "devices = device_1, device_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### मूल उदाहरण\n",
    "\n",
    "आइए एक फ़ंक्शन को परिभाषित करें जिसे हम एक योजना में बदलना चाहते हैं। ऐसा करने के लिए, यह फ़ंक्शन परिभाषा के ऊपर एक डेकोरेटर जोड़ने जैसा सरल है!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@sy.func2plan()\n",
    "def plan_double_abs(x):\n",
    "    x = x + x\n",
    "    x = torch.abs(x)\n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "चलिए चेक करते हैं, हाँ अब हमारे पास एक प्लान है!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plan_double_abs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "किसी प्लान का उपयोग करने के लिए, आपको दो चीजों की आवश्यकता होती है: प्लान बनाना (_अर्थात फ़ंक्शन में मौजूद संचालन के अनुक्रम को पंजीकृत करें_) और इसे एक कार्यकर्ता / उपकरण को भेजना। सौभाग्य से आप यह बहुत आसानी से कर सकते हैं!\n",
    "\n",
    "#### एक योजना का निर्माण\n",
    "\n",
    "एक प्लान बनाने के लिए आपको बस कुछ डेटा पर कॉल करना होगा।\n",
    "\n",
    "चलो पहले कुछ दूरस्थ डेटा का संदर्भ प्राप्त करते हैं: एक अनुरोध नेटवर्क पर भेजा जाता है और एक संदर्भ पॉइंटर लौटाया जाता है।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointer_to_data = device_1.search('input_data')[0]\n",
    "pointer_to_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "यदि हम प्लान को बताते हैं इसे डिवाइस पर दूरस्थ रूप से निष्पादित किया जाना चाहिए `location: device_1` ... हम एक त्रुटि प्राप्त करेंगे क्योंकि प्लान अभी तक नहीं बनाया गया था।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plan_double_abs.is_built"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sending non-built Plan will fail\n",
    "try:\n",
    "    plan_double_abs.send(device_1)\n",
    "except RuntimeError as error:\n",
    "    print(error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "एक योजना बनाने के लिए आपको योजना पर `build` कॉल करने की आवश्यकता है और प्लान को निष्पादित करने के लिए आवश्यक तर्क पास करें (कुछ डेटा a.k.a)। जब एक प्लान का निर्माण किया जाता है तो सभी कमांड स्थानीय कार्यकर्ता द्वारा क्रमिक रूप से निष्पादित किए जाते हैं, और योजना द्वारा पकड़े जाते हैं और अपने `actions` विशेषता में संग्रहीत होते हैं!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plan_double_abs.build(torch.tensor([1., -2.]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plan_double_abs.is_built"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "अगर हम प्लान को भेजने की कोशिश करते हैं तो यह काम करता है!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This cell is executed successfully\n",
    "pointer_plan = plan_double_abs.send(device_1)\n",
    "pointer_plan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "तब तक टेंसर्स के साथ, हमें भेजे गए ऑब्जेक्ट को एक पॉइंटर मिलता है। यहाँ इसे बस एक 'PointerPlan' कहा जाता है।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "याद रखने वाली एक महत्वपूर्ण बात यह है कि जब कोई प्लान का निर्माण किया जाता है, तो हम आईडी(एस) को आगे पूर्व निर्धारित करते हैं, जहां परिणाम(ओं) को संग्रहीत किया जाना चाहिए। यह आदेशों को अतुल्यकालिक रूप से भेजने की अनुमति देगा, पहले से ही एक आभासी परिणाम के संदर्भ में और दूरस्थ परिणाम की गणना किए बिना स्थानीय गणना जारी रखने के लिए। एक प्रमुख अनुप्रयोग है जब आपको device_1 पर एक बैच की गणना की आवश्यकता होती है और device_2 पर दूसरे बैच की गणना शुरू करने के लिए इस गणना के समाप्त होने का इंतजार नहीं करना चाहते।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "#### एक योजना दूरस्थ रूप से चलाना\n",
    "\n",
    "अब हम प्‍वाइंटर को प्‍लान से कुछ डेटा के साथ प्‍लान को कॉल करके रिमोट को रन कर सकते हैं। यह इस योजना को दूरस्थ रूप से चलाने के लिए एक आदेश जारी करता है, ताकि योजना के आउटपुट का पूर्वनिर्धारित स्थान अब परिणाम को शामिल करें (याद रखें कि हम गणना से पहले परिणाम के पूर्व-निर्धारित स्थान को याद करते हैं)। इसके लिए एकल संचार दौर की भी आवश्यकता होती है।\n",
    "\n",
    "परिणाम बस एक सूचक है, जैसे जब आप एक सामान्य हुक torch फ़ंक्शन कहते हैं!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointer_to_result = pointer_plan(pointer_to_data)\n",
    "print(pointer_to_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "और आप बस मान वापस पूछ सकते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointer_to_result.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### एक ठोस उदाहरण की ओर\n",
    "\n",
    "लेकिन हम जो करना चाहते हैं, वह प्‍लान को गहरी और संघबद्ध शिक्षा पर लागू करना है, है ना? तो चलो थोड़ा और अधिक जटिल उदाहरण देखें, neural नेटवर्क का उपयोग करते हुए जैसा कि आप उन्हें उपयोग करने के लिए तैयार हो सकते हैं।\n",
    "ध्यान दें कि अब हम एक वर्ग को एक योजना में बदल रहे हैं। ऐसा करने के लिए, हम अपनी कक्षा को sy.Plan (nn.Module से विरासत में लेने के बजाय) से वारिस करते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(sy.Plan):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(2, 3)\n",
    "        self.fc2 = nn.Linear(3, 2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return F.log_softmax(x, dim=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = Net()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "आइए कुछ मॉक डेटा का उपयोग करके प्‍लान का निर्माण करें।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.build(torch.tensor([1., 2.]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "अब हम एक दूरस्थ कार्यकर्ता को प्‍लान भेजते हैं"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointer_to_net = net.send(device_1)\n",
    "pointer_to_net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "चलो कुछ दूरस्थ डेटा पुनर्प्राप्त करते हैं"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointer_to_data = device_1.search('input_data')[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "फिर, वाक्यविन्यास सामान्य दूरस्थ अनुक्रमिक निष्पादन की तरह है, अर्थात, स्थानीय निष्पादन की तरह। लेकिन क्लासिक रिमोट निष्पादन की तुलना में, प्रत्येक निष्पादन के लिए एक एकल संचार दौर है।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointer_to_result = pointer_to_net(pointer_to_data)\n",
    "pointer_to_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "और हम हमेशा की तरह परिणाम प्राप्त करते हैं!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointer_to_result.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "Et voilà! हमने देखा है कि स्थानीय कार्यकर्ता (या सर्वर) और दूरस्थ उपकरणों के बीच संचार को नाटकीय रूप से कैसे कम करें!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### कार्यकर्ताओं के बीच स्विच करें\n",
    "\n",
    "एक प्रमुख विशेषता जो हम चाहते हैं कि कई श्रमिकों के लिए एक ही प्‍लान का उपयोग किया जाए, हम जिस डेटा पर विचार कर रहे हैं, उसके आधार पर हम बदलेंगे।\n",
    "विशेष रूप से, हम हर बार जब हम कार्यकर्ता बदलते हैं तो प्‍लान का पुनर्निर्माण नहीं करना चाहते हैं। आइए देखें कि हम अपने छोटे नेटवर्क के साथ पिछले उदाहरण का उपयोग करके यह कैसे करते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(sy.Plan):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(2, 3)\n",
    "        self.fc2 = nn.Linear(3, 2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return F.log_softmax(x, dim=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = Net()\n",
    "\n",
    "# Build plan\n",
    "net.build(torch.tensor([1., 2.]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "यहां मुख्य कदम हैं जिन्हें हमने निष्पादित किया है"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointer_to_net_1 = net.send(device_1)\n",
    "pointer_to_data = device_1.search('input_data')[0]\n",
    "pointer_to_result = pointer_to_net_1(pointer_to_data)\n",
    "pointer_to_result.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "और वास्तव में आप एक ही प्‍लान से अन्य पॉइंटरप्लान(PointerPlans) का निर्माण कर सकते हैं, इसलिए सिंटैक्स किसी अन्य डिवाइस की प्‍लान को दूरस्थ रूप से चलाने के लिए समान है"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointer_to_net_2 = net.send(device_2)\n",
    "pointer_to_data = device_2.search('input_data')[0]\n",
    "pointer_to_result = pointer_to_net_2(pointer_to_data)\n",
    "pointer_to_result.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "> नोट: वर्तमान में, प्‍लान वर्गों के साथ, आप केवल एक ही विधि का उपयोग कर सकते हैं और आपको इसे \"forward\" नाम देना होगा।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "###  प्‍लान फ़ंक्शंस का स्वचालित रूप से निर्माण\n",
    "\n",
    "फ़ंक्शंस के लिए (`@` `sy.func2plan`) हम प्‍लान को स्पष्ट रूप से  `build` कहने के बग़ैर स्वचालित रूप से बना सकते हैं, वास्तव में प्‍लान के निर्माण के क्षण में पहले से ही निर्मित है।\n",
    "\n",
    "इस कार्यक्षमता को प्राप्त करने के लिए केवल एक प्‍लान बनाते समय आपको बदलने की आवश्यकता होती है, सजावट के लिए एक तर्क स्थापित कर रहा है जिसे `args_shape` कहा जाता है, जिसमें प्रत्येक तर्क के आकार वाली एक सूची होनी चाहिए।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@sy.func2plan(args_shape=[(-1, 1)])\n",
    "def plan_double_abs(x):\n",
    "    x = x + x\n",
    "    x = torch.abs(x)\n",
    "    return x\n",
    "\n",
    "plan_double_abs.is_built"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "`args_shape` पैरामीटर का उपयोग आंतरिक रूप से दिए गए आकार के साथ नकली टेंसर बनाने के लिए किया जाता है जो प्‍लान बनाने के लिए उपयोग किए जाते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@sy.func2plan(args_shape=[(1, 2), (-1, 2)])\n",
    "def plan_sum_abs(x, y):\n",
    "    s = x + y\n",
    "    return torch.abs(s)\n",
    "\n",
    "plan_sum_abs.is_built"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "आप फ़ंक्शन को state elements भी प्रदान कर सकते हैं!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@sy.func2plan(args_shape=[(1,)], state=(torch.tensor([1]), ))\n",
    "def plan_abs(x, state):\n",
    "    bias, = state.read()\n",
    "    x = x.abs()\n",
    "    return x + bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointer_plan = plan_abs.send(device_1)\n",
    "x_ptr = torch.tensor([-1, 0]).send(device_1)\n",
    "p = pointer_plan(x_ptr)\n",
    "p.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "इसके बारे में अधिक जानने के लिए, आप खोज सकते हैं कि हम ट्यूटोरियल भाग 8 बीआईएस में प्रोटोकॉल के साथ योजनाओं का उपयोग कैसे करते हैं!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### GitHub पर स्टार PySyft\n",
    "\n",
    "हमारे समुदाय की मदद करने का सबसे आसान तरीका सिर्फ रिपॉजिटरी को अभिनीत करना है! यह हमारे द्वारा बनाए जा रहे कूल टूल्स के बारे में जागरूकता बढ़ाने में मदद करता है।\n",
    "\n",
    "- [स्टार पायसफ्ट](https://github.com/OpenMined/PySyft)\n",
    "\n",
    "### GitHub पर हमारे ट्यूटोरियल चुनना!\n",
    "\n",
    "हमने फेडरेटेड और प्राइवेसी-प्रिजर्विंग लर्निंग और उसकी संरचना की बेहतर समझ प्राप्त करने के लिए वास्तव में अच्छा ट्यूटोरियल बनाया है।\n",
    "\n",
    "- [PySyft ट्यूटोरियल्स को चेक करें](https://github.com/OpenMined/PySyft/tree/master/examples/tutorials)\n",
    "\n",
    "\n",
    "### हमारे Slack में शामिल हों!\n",
    "\n",
    "नवीनतम प्रगति पर अद्यतित रहने का सबसे अच्छा तरीका हमारे समुदाय में शामिल होना है!\n",
    "\n",
    "- [slack.openmined.org से जुड़ें](http://slack.openmined.org)\n",
    "\n",
    "### एक कोड परियोजना में शामिल हों!\n",
    "\n",
    "हमारे समुदाय में योगदान करने का सबसे अच्छा तरीका एक कोड योगदानकर्ता बनना है! यदि आप \"one off\" मिनी-प्रोजेक्ट्स शुरू करना चाहते हैं, तो आप PySyft GitHub जारी करने वाले पृष्ठ पर जा सकते हैं और `Good First Issue` के रूप में चिह्नित मुद्दों की खोज कर सकते हैं।\n",
    "\n",
    "- [Good First Issue Tickets](https://github.com/OpenMined/PySyft/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n",
    "\n",
    "### दान करना\n",
    "\n",
    "यदि आपके पास हमारे कोडबेस में योगदान करने का समय नहीं है, लेकिन फिर भी समर्थन उधार देना चाहते हैं, तो आप हमारे ओपन कलेक्टिव में भी एक बैकर बन सकते हैं। सभी दान हमारी वेब होस्टिंग और अन्य सामुदायिक खर्च जैसे कि हैकाथॉन और मीटअप की ओर जाते हैं!\n",
    "\n",
    "- [OpenMined's Open कलेक्टिव पेज के माध्यम से दान करें](https://opencollective.com/openmined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "nbTranslate": {
   "displayLangs": [
    "hi"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "hi",
   "useGoogleTranslate": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
